/*
    * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Oracle designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package sun.tools.jmap;
  
  import java.lang.reflect.Method;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  
  import com.sun.tools.attach.VirtualMachine;
  import com.sun.tools.attach.AttachNotSupportedException;
  import sun.tools.attach.HotSpotVirtualMachine;
  
  /*
   * This class is the main class for the JMap utility. It parses its arguments
   * and decides if the command should be satisifed using the VM attach mechanism
   * or an SA tool. At this time the only option that uses the VM attach mechanism
   * is the -dump option to get a heap dump of a running application. All other
   * options are mapped to SA tools.
   */
  public class JMap {
  
      // Options handled by the attach mechanism
      private static String HISTO_OPTION = "-histo";
      private static String LIVE_HISTO_OPTION = "-histo:live";
      private static String DUMP_OPTION_PREFIX = "-dump:";
  
      // These options imply the use of a SA tool
      private static String SA_TOOL_OPTIONS =
        "-heap|-heap:format=b|-permstat|-finalizerinfo";
  
      // The -F (force) option is currently not passed through to SA
      private static String FORCE_SA_OPTION = "-F";
  
      // Default option (if nothing provided)
      private static String DEFAULT_OPTION = "-pmap";
  
      public static void main(String[] args) throws Exception {
          if (args.length == 0) {
              usage(); // no arguments
          }
  
          // used to indicate if we should use SA
          boolean useSA = false;
  
          // the chosen option (-heap, -dump:*, ... )
          String option = null;
  
          // First iterate over the options (arguments starting with -).  There should be
          // one (but maybe two if -F is also used).
          int optionCount = 0;
          while (optionCount < args.length) {
              String arg = args[optionCount];
              if (!arg.startsWith("-")) {
                  break;
              }
              if (arg.equals(FORCE_SA_OPTION)) {
                  useSA = true;
              } else {
                  if (option != null) {
                      usage();  // option already specified
                  }
                  option = arg;
              }
              optionCount++;
          }
  
          // if no option provided then use default.
          if (option == null) {
              option = DEFAULT_OPTION;
          }
          if (option.matches(SA_TOOL_OPTIONS)) {
              useSA = true;
          }
  
          // Next we check the parameter count. For the SA tools there are
         // one or two parameters. For the built-in -dump option there is
         // only one parameter (the process-id)
         int paramCount = args.length - optionCount;
         if (paramCount == 0 || paramCount > 2) {
             usage();
         }
 
         if (optionCount == 0 || paramCount != 1) {
             useSA = true;
         } else {
             // the parameter for the -dump option is a process-id.
             // If it doesn't parse to a number then it must be SA
             // debug server
             if (!args[optionCount].matches("[0-9]+")) {
                 useSA = true;
             }
         }
 
 
         // at this point we know if we are executing an SA tool or a built-in
         // option.
 
         if (useSA) {
             // parameters (<pid> or <exe> <core>)
             String params[] = new String[paramCount];
             for (int i=optionCount; i<args.length; i++ ){
                 params[i-optionCount] = args[i];
             }
             runTool(option, params);
 
         } else {
             String pid = args[1];
             // Here we handle the built-in options
             // As more options are added we should create an abstract tool class and
             // have a table to map the options
             if (option.equals(HISTO_OPTION)) {
                 histo(pid, false);
             } else if (option.equals(LIVE_HISTO_OPTION)) {
                 histo(pid, true);
             } else if (option.startsWith(DUMP_OPTION_PREFIX)) {
                 dump(pid, option);
             } else {
                 usage();
             }
         }
     }
 
     // Invoke SA tool  with the given arguments
     private static void runTool(String option, String args[]) throws Exception {
         String[][] tools = {
             { "-pmap",           "sun.jvm.hotspot.tools.PMap"     },
             { "-heap",           "sun.jvm.hotspot.tools.HeapSummary"     },
             { "-heap:format=b",  "sun.jvm.hotspot.tools.HeapDumper"      },
             { "-histo",          "sun.jvm.hotspot.tools.ObjectHistogram" },
             { "-permstat",       "sun.jvm.hotspot.tools.PermStat"        },
             { "-finalizerinfo",  "sun.jvm.hotspot.tools.FinalizerInfo"   },
         };
 
         String tool = null;
 
         // -dump option needs to be handled in a special way
         if (option.startsWith(DUMP_OPTION_PREFIX)) {
             // first check that the option can be parsed
             String fn = parseDumpOptions(option);
             if (fn == null) usage();
 
             // tool for heap dumping
             tool = "sun.jvm.hotspot.tools.HeapDumper";
 
             // HeapDumper -f <file>
             args = prepend(fn, args);
             args = prepend("-f", args);
         } else {
             int i=0;
             while (i < tools.length) {
                 if (option.equals(tools[i][0])) {
                     tool = tools[i][1];
                     break;
                 }
                 i++;
             }
         }
         if (tool == null) {
             usage();   // no mapping to tool
         }
 
         // Tool not available on this  platform.
         Class<?> c = loadClass(tool);
         if (c == null) {
             usage();
         }
 
         // invoke the main method with the arguments
         Class[] argTypes = { String[].class } ;
         Method m = c.getDeclaredMethod("main", argTypes);
 
         Object[] invokeArgs = { args };
         m.invoke(null, invokeArgs);
     }
 
     // loads the given class using the system class loader
     private static Class loadClass(String name) {
         //
         // We specify the system clas loader so as to cater for development
         // environments where this class is on the boot class path but sa-jdi.jar
         // is on the system class path. Once the JDK is deployed then both
         // tools.jar and sa-jdi.jar are on the system class path.
         //
         try {
             return Class.forName(name, true,
                                  ClassLoader.getSystemClassLoader());
         } catch (Exception x)  { }
         return null;
     }
 
     private static final String LIVE_OBJECTS_OPTION = "-live";
     private static final String ALL_OBJECTS_OPTION = "-all";
     private static void histo(String pid, boolean live) throws IOException {
         VirtualMachine vm = attach(pid);
         InputStream in = ((HotSpotVirtualMachine)vm).
             heapHisto(live ? LIVE_OBJECTS_OPTION : ALL_OBJECTS_OPTION);
         drain(vm, in);
     }
 
     private static void dump(String pid, String options) throws IOException {
         // parse the options to get the dump filename
         String filename = parseDumpOptions(options);
         if (filename == null) {
             usage();  // invalid options or no filename
         }
 
         // get the canonical path - important to avoid just passing
         // a "heap.bin" and having the dump created in the target VM
         // working directory rather than the directory where jmap
         // is executed.
         filename = new File(filename).getCanonicalPath();
 
         // dump live objects only or not
         boolean live = isDumpLiveObjects(options);
 
         VirtualMachine vm = attach(pid);
         System.out.println("Dumping heap to " + filename + " ...");
         InputStream in = ((HotSpotVirtualMachine)vm).
             dumpHeap((Object)filename,
                      (live ? LIVE_OBJECTS_OPTION : ALL_OBJECTS_OPTION));
         drain(vm, in);
     }
 
     // Parse the options to the -dump option. Valid options are format=b and
     // file=<file>. Returns <file> if provided. Returns null if <file> not
     // provided, or invalid option.
     private static String parseDumpOptions(String arg) {
         assert arg.startsWith(DUMP_OPTION_PREFIX);
 
         String filename = null;
 
         // options are separated by comma (,)
         String options[] = arg.substring(DUMP_OPTION_PREFIX.length()).split(",");
 
         for (int i=0; i<options.length; i++) {
             String option = options[i];
 
             if (option.equals("format=b")) {
                 // ignore format (not needed at this time)
             } else if (option.equals("live")) {
                 // a valid suboption
             } else {
 
                 // file=<file> - check that <file> is specified
                 if (option.startsWith("file=")) {
                     filename = option.substring(5);
                     if (filename.length() == 0) {
                         return null;
                     }
                 } else {
                     return null;  // option not recognized
                 }
             }
         }
         return filename;
     }
 
     private static boolean isDumpLiveObjects(String arg) {
         // options are separated by comma (,)
         String options[] = arg.substring(DUMP_OPTION_PREFIX.length()).split(",");
         for (String suboption : options) {
             if (suboption.equals("live")) {
                 return true;
             }
         }
         return false;
     }
 
     // Attach to <pid>, existing if we fail to attach
     private static VirtualMachine attach(String pid) {
         try {
             return VirtualMachine.attach(pid);
         } catch (Exception x) {
             String msg = x.getMessage();
             if (msg != null) {
                 System.err.println(pid + ": " + msg);
             } else {
                 x.printStackTrace();
             }
             if ((x instanceof AttachNotSupportedException) && haveSA()) {
                 System.err.println("The -F option can be used when the " +
                   "target process is not responding");
             }
             System.exit(1);
             return null; // keep compiler happy
         }
     }
 
     // Read the stream from the target VM until EOF, then detach
     private static void drain(VirtualMachine vm, InputStream in) throws IOException {
         // read to EOF and just print output
         byte b[] = new byte[256];
         int n;
         do {
             n = in.read(b);
             if (n > 0) {
                 String s = new String(b, 0, n, "UTF-8");
                 System.out.print(s);
             }
         } while (n > 0);
         in.close();
         vm.detach();
     }
 
     // return a new string array with arg as the first element
     private static String[] prepend(String arg, String args[]) {
         String[] newargs = new String[args.length+1];
         newargs[0] = arg;
         System.arraycopy(args, 0, newargs, 1, args.length);
         return newargs;
     }
 
     // returns true if SA is available
     private static boolean haveSA() {
         Class c = loadClass("sun.jvm.hotspot.tools.HeapSummary");
         return (c != null);
     }
 
     // print usage message
     private static void usage() {
         System.out.println("Usage:");
         if (haveSA()) {
             System.out.println("    jmap [option] <pid>");
             System.out.println("        (to connect to running process)");
             System.out.println("    jmap [option] <executable <core>");
             System.out.println("        (to connect to a core file)");
             System.out.println("    jmap [option] [server_id@]<remote server IP or hostname>");
             System.out.println("        (to connect to remote debug server)");
             System.out.println("");
             System.out.println("where <option> is one of:");
             System.out.println("    <none>               to print same info as Solaris pmap");
             System.out.println("    -heap                to print java heap summary");
             System.out.println("    -histo[:live]        to print histogram of java object heap; if the \"live\"");
             System.out.println("                         suboption is specified, only count live objects");
             System.out.println("    -permstat            to print permanent generation statistics");
             System.out.println("    -finalizerinfo       to print information on objects awaiting finalization");
             System.out.println("    -dump:<dump-options> to dump java heap in hprof binary format");
             System.out.println("                         dump-options:");
             System.out.println("                           live         dump only live objects; if not specified,");
             System.out.println("                                        all objects in the heap are dumped.");
             System.out.println("                           format=b     binary format");
             System.out.println("                           file=<file>  dump heap to <file>");
             System.out.println("                         Example: jmap -dump:live,format=b,file=heap.bin <pid>");
             System.out.println("    -F                   force. Use with -dump:<dump-options> <pid> or -histo");
             System.out.println("                         to force a heap dump or histogram when <pid> does not");
             System.out.println("                         respond. The \"live\" suboption is not supported");
             System.out.println("                         in this mode.");
             System.out.println("    -h | -help           to print this help message");
             System.out.println("    -J<flag>             to pass <flag> directly to the runtime system");
         } else {
             System.out.println("    jmap -histo <pid>");
             System.out.println("      (to connect to running process and print histogram of java object heap");
             System.out.println("    jmap -dump:<dump-options> <pid>");
             System.out.println("      (to connect to running process and dump java heap)");
             System.out.println("");
             System.out.println("    dump-options:");
             System.out.println("      format=b     binary default");
             System.out.println("      file=<file>  dump heap to <file>");
             System.out.println("");
             System.out.println("    Example:       jmap -dump:format=b,file=heap.bin <pid>");
         }
 
         System.exit(1);
     }
 }